﻿
#include "Engine/common.h"
#include "DNF定义.h"
#include "DNF对象定义.h"

//增幅强化锻造
//////////////////////////////////////////////////////////////////////////

//无,光杖,念珠,图腾,镰刀,战斧,光剑,巨剑,短剑,太刀,钝器
float 武器物攻系数[武器类型总数]={0.0000, 
	0.9900, 0.9810, 0.9945, 0.9945, 1.0080,
	0.9837, 1.0080, 0.9855, 0.9855, 0.9990};
float 武器魔攻系数[武器类型总数]={0.0000, 
	0.9855, 1.0035, 0.9810, 0.9945, 0.9765,
	0.9810, 0.9810, 1.0035, 0.9945, 0.9855};

//普通,高级,稀有,神器,勇者,传说,史诗,史诗Plus,太初Lite,太初
float 品质系数[拓展品质总数]={0.40, 0.70, 1.00, 1.25, 1.10, 1.35, 1.45, 1.45, 1.55, 1.55};

float 品质常数[拓展品质总数]={8, 8, 10, 12, 11, 13, 14, 15, 14, 15};
float 锻造品质常数[拓展品质总数]={8, 8, 10, 12, 10, 13, 14, 15, 14, 15};
float 耳环品质常数[拓展品质总数]={24, 30, 26, 28, 0, 29, 30, 31, 0, 0};
float 左右槽品质常数[拓展品质总数]={24, 24, 26, 28, 27, 29, 30, 31, 0, 0};
//+0~+20
float 武器强化等级系数[21]={0, 20, 26, 36, 47, 58, 69, 82, 110, 146, 187, 269, 367, 430, 492, 554, 617, 680, 743, 806, 869};
float 耳环三攻等级系数[21]={0, 83, 124, 166, 207, 248, 314, 370, 426, 482, 621, 970, 1455, 1941, 2911, 4043, 5175, 7116, 9056, 10997, 13099};
float 左右槽增幅等级系数[21]={0, 8, 12, 16, 20, 24, 28, 33, 38, 43, 48, 90.3, 135, 180.6, 270, 375, 480, 660, 840, 1020, 1215};
//+0~+8
float 锻造等级系数[9]={0, 2, 3, 4, 6, 8, 13, 18, 25};

//+0~+20
float 增幅等级系数[21]={0, 1, 2, 3, 4, 6, 8, 10, 22, 28, 35, 42, 50, 67, 108, 150, 192, 267, 342, 417, 500};
//缺少数据，且取整误差太大，史诗Plus和太初Lite的参数可能有误
float 增幅品质系数[拓展品质总数]={0, 0, 1.0, 1.3, 1.1, 1.4, 1.5, 1.5, 1.6, 1.6};
float 增幅品质常数1[拓展品质总数]={0, 0, 45, 45, 45, 46, 46, 45, 45, 46};
float 增幅品质常数2[拓展品质总数]={0, 0, 5, 6, 5, 6, 12, 13, 13, 13};

int 计算武器强化物攻(int 等级,int 品质,DNF武器类型 武器类型)
{
	int 装备等级=105;
	float 结果=(装备等级+品质常数[品质])*武器强化等级系数[等级]*武器物攻系数[武器类型]*品质系数[品质]/72;
	return (int)结果;
}

int 计算武器强化魔攻(int 等级,int 品质,DNF武器类型 武器类型)
{
	int 装备等级=105;
	float 结果=(装备等级+品质常数[品质])*武器强化等级系数[等级]*武器魔攻系数[武器类型]*品质系数[品质]/72;
	return (int)结果;
}

int 计算武器锻造独立(int 等级,int 品质,DNF武器类型 武器类型)
{
	int 装备等级=105;
	float 结果=(装备等级+锻造品质常数[品质])*0.125*品质系数[品质]*锻造等级系数[等级];
	return (int)fround(结果,0);
}

int 计算辅助武器锻造四维(int 等级,int 品质,DNF武器类型 武器类型)
{
	int 装备等级=105;
	float 结果=(装备等级+锻造品质常数[品质])*0.0125*品质系数[品质]*锻造等级系数[等级];
	if (武器类型==武器_光杖 && 当前职业对象->是辅助职业())
		return (int)fround(结果,0);
	return 0;
}

int 计算增幅四维(int 等级,int 品质)
{
	int 装备等级=105;
	float 结果=(装备等级+ 增幅品质常数1[品质])*增幅品质系数[品质]*增幅等级系数[等级]*0.01+增幅品质常数2[品质];
	if (等级>11)
		结果+=5;
	return (int)结果;
}

int 计算左右槽强化额外四维(int 等级,int 品质)
{
	int 装备等级=105;
	float 结果=(装备等级+左右槽品质常数[品质])*品质系数[品质]*左右槽增幅等级系数[等级]/321;
	return (int)结果;
}

int 计算耳环强化三攻(int 等级,int 品质)
{
	int 装备等级=105;
	float 结果=(装备等级+耳环品质常数[品质])*品质系数[品质]*耳环三攻等级系数[等级]/2400;
	return (int)结果;
}


//装扮对象
//////////////////////////////////////////////////////////////////////////
void DNF装扮对象::设置装扮参数(DNF装扮部位 部位,int 品质索引,int 属性索引)
{
	装扮部位品质[部位]=品质索引;		//高级~神器，索引0对应无装扮（不是普通）
	装扮属性索引[部位]=属性索引;		//忽略上衣
}

void DNF装扮对象::设置上衣技能(WCHAR* 上衣技能)
{
	wcscpy(this->上衣技能,上衣技能);
}

void DNF装扮对象::应用属性()
{
	float 头部帽子智力[4]={0,45,55,65};
	float 头部帽子施放[4]={0,PC(12),PC(14),PC(16)};
	float 脸部胸部攻速[4]={0,PC(5.0),PC(6.0),PC(7.0)};
	float 脸部胸部异抗[4]={0,PC(3.0),PC(3.6),PC(4.2)};
	float 腰部力量[4]={0,0,55,65};	//高级装扮不可选力量
	float 腰部属抗[4]={0,25,35,45};
	float 鞋子力量[4]={0,45,55,65};
	float 鞋子移速[4]={0,PC(5.0),PC(6.0),PC(7.0)};

	if (装扮部位品质[装扮头部]!=0)
	{
		if (装扮属性索引[装扮头部]==0)
			当前角色对象->智力增加(头部帽子智力[装扮部位品质[装扮头部]]);
		else if (装扮属性索引[装扮头部]==1)
			当前角色对象->施放加速(头部帽子施放[装扮部位品质[装扮头部]]);
		//忽略其他
	}

	if (装扮部位品质[装扮帽子]!=0)
	{
		if (装扮属性索引[装扮帽子]==0)
		当前角色对象->智力增加(头部帽子智力[装扮部位品质[装扮帽子]]);
		else if (装扮属性索引[装扮帽子]==1)
			当前角色对象->施放加速(头部帽子施放[装扮部位品质[装扮帽子]]);
		//忽略其他
	}

	if (装扮部位品质[装扮脸部]!=0)
	{
		if (装扮属性索引[装扮脸部]==0)
			当前角色对象->攻速增加(脸部胸部攻速[装扮部位品质[装扮脸部]]);
		else if (装扮属性索引[装扮脸部]==1)
			当前角色对象->全异抗增加(脸部胸部异抗[装扮部位品质[装扮脸部]]);
		//忽略其他
	}

	if (装扮部位品质[装扮胸部]!=0)
	{
		if (装扮属性索引[装扮胸部]==0)
			当前角色对象->攻速增加(脸部胸部攻速[装扮部位品质[装扮胸部]]);
		else if (装扮属性索引[装扮胸部]==1)
			当前角色对象->全异抗增加(脸部胸部异抗[装扮部位品质[装扮胸部]]);
	}

	if (装扮部位品质[装扮上衣]!=0)
	{
		//设置模块肯定知道名字，忽略了无意义的技能
		//高级装扮没有暗黑斩和浮空击
		当前职业对象->技能等级增加(上衣技能,1);
	}
	
	//装扮下装无伤害属性，忽略

	if (装扮部位品质[装扮腰部]!=0)
	{
		if (装扮属性索引[装扮腰部]==0)
			当前角色对象->力量增加(腰部力量[装扮部位品质[装扮腰部]]);
		else if (装扮属性索引[装扮腰部]==1)
			当前角色对象->火抗增加(腰部属抗[装扮部位品质[装扮腰部]]);
		else if (装扮属性索引[装扮腰部]==2)
			当前角色对象->冰抗增加(腰部属抗[装扮部位品质[装扮腰部]]);
		else if (装扮属性索引[装扮腰部]==3)
			当前角色对象->光抗增加(腰部属抗[装扮部位品质[装扮腰部]]);
		else if (装扮属性索引[装扮腰部]==4)
			当前角色对象->暗抗增加(腰部属抗[装扮部位品质[装扮腰部]]);
		//忽略其他（体力等）
	}

	if (装扮部位品质[装扮鞋子]!=0)
	{
		if (装扮属性索引[装扮鞋子]==0)
			当前角色对象->力量增加(鞋子力量[装扮部位品质[装扮鞋子]]);
		else if (装扮属性索引[装扮鞋子]==1)
			当前角色对象->移速增加(鞋子移速[装扮部位品质[装扮鞋子]]);
		//忽略其他
	
	}

	//套装属性，稀有可与神器混搭
	int 高级数量=0;
	int 稀有数量=0;
	int 神器数量=0;
	for (int i=0;i<装扮部位总数;i++)
	{
		if (装扮部位品质[i]==高级)
			高级数量++;
		if (装扮部位品质[i]==稀有)
			稀有数量++;
		if (装扮部位品质[i]==神器)
			神器数量++;
	}
	//[高级]和[稀有/神器]独立触发
	if (高级数量>=3)
	{
		当前角色对象->四维增加(10);
	}
	if (高级数量>=5)
	{
		//无伤害相关属性
	}
	if (高级数量>=8)
	{
		当前角色对象->四维增加(10);
		当前角色对象->三速增加(PC(1.0));
	}

	//混搭规则不像装备那样分别触发2套
	//而是每个阶段二选一，神器足够触发神器，神器+稀有够了触发稀有，否则不触发
	if (神器数量>=3)
	{
		当前角色对象->四维增加(50);
		当前角色对象->三速增加(PC(3.0));
	}
	else if (稀有数量+神器数量>=3)
	{
		当前角色对象->四维增加(40);
		当前角色对象->三速增加(PC(2.0));
	}
	if (神器数量>=5)
	{
		//无伤害相关属性
	}
	else if (稀有数量+神器数量>=5)
	{
		//无伤害相关属性
	}
	if (神器数量>=8)
	{
		当前角色对象->四维增加(50);
		当前角色对象->三速增加(PC(3.0));
		当前角色对象->全属抗增加(15);
		当前角色对象->全属强增加(10);
	}
	else if (稀有数量+神器数量>=8)
	{
		当前角色对象->四维增加(40);
		当前角色对象->三速增加(PC(2.0));
		当前角色对象->全属抗增加(15);
		当前角色对象->全属强增加(6);
	}
}


//辟邪玉对象
//////////////////////////////////////////////////////////////////////////
void DNF辟邪玉对象::设置辟邪玉参数(int 编号,int 词条索引,float 词条数值)
{
	辟邪玉词条索引[编号]=词条索引;
	辟邪玉词条数值[编号]=词条数值;
}

void DNF辟邪玉对象::应用属性()
{
	float 技伤提升累加=0.0f;
	for (int i=0;i<4;i++)
	{
		switch (辟邪玉词条索引[i])
		{
		case 0:	//无
			break;
		case 1:	//技能伤害增加
			技伤提升累加+=辟邪玉词条数值[i];
			break;
		case 2:	//[装备属性强化增加]增幅
			//在 计算辟邪玉属强加成() 里专门处理
			break;
			//老词条已弃用，不再影响伤害，只加攻击强化增幅
		case 3:	//[火属性附加伤害增加]增幅
		case 4:	//[冰属性附加伤害增加]增幅
		case 5:	//[光属性附加伤害增加]增幅
		case 6:	//[暗属性附加伤害增加]增幅
		case 7:	//[附加伤害增加]增幅
		case 8:	//[暴击伤害增加]增幅
		case 9:	//[伤害增加]增幅
		case 10:	//[最终伤害增加]增幅
			当前角色对象->攻击强化增幅增加(辟邪玉词条数值[i]);
			break;
		case 11:	//[力智增加]增幅，会影响面板
			当前角色对象->攻击强化增幅增加(辟邪玉词条数值[i]);
			当前角色对象->力智百分比增加(辟邪玉词条数值[i]);
			break;
		case 12:	//[三攻增加]增幅，会影响面板
			当前角色对象->攻击强化增幅增加(辟邪玉词条数值[i]);
			当前角色对象->三攻百分比增加(辟邪玉词条数值[i]);
			break;
		case 13:	//三速增加
			当前角色对象->三速增加(辟邪玉词条数值[i]);
			break;
		case 14:	//10~15级全部技能+1
			当前职业对象->技能等级增加(10,15,1,全部技能);
			break;
		case 15:	//20~25级全部技能+1
			当前职业对象->技能等级增加(20,25,1,全部技能);
			break;
		case 16:	//30~35级全部技能+1
			当前职业对象->技能等级增加(30,35,1,全部技能);
			break;
		case 17:	//40~45级全部技能+1
			当前职业对象->技能等级增加(40,45,1,全部技能);
			break;
		case 18:	//55~60级全部技能+1
			当前职业对象->技能等级增加(55,60,1,全部技能);
			break;
		case 19:	//65~70级全部技能+1
			当前职业对象->技能等级增加(65,70,1,全部技能);
			break;
		case 20:	//75~80级全部技能+1
			当前职业对象->技能等级增加(75,80,1,全部技能);
			break;
		case 21:	//一次觉醒主动技能+1
			当前职业对象->技能等级增加(50,50,1,觉醒技能);
			break;
		case 22:	//二次觉醒主动技能+1
			当前职业对象->技能等级增加(85,85,1,觉醒技能);
			break;
		}
	}
	if (技伤提升累加!=0)
		当前角色对象->技能伤害提升(技伤提升累加);
}

void DNF辟邪玉对象::计算辟邪玉属强加成(int* 火强结果,int* 冰强结果,int* 光强结果,int* 暗强结果)
{
	float 装备属性强化增加增幅=0.0f;
	for (int i=0;i<4;i++)
	{
		if (辟邪玉词条索引[i]==2)
			装备属性强化增加增幅+=辟邪玉词条数值[i];
	}
	//婚戒和唤醒不计入，结果向下取整
	//https://www.bilibili.com/video/BV13QB3YHE7b
	if (火强结果!=NULL)
		*火强结果=装备属性强化增加增幅*(当前角色对象->角色属性[DNF角色对象::角色火属性强化]-当前角色对象->结婚属强-13);
	if (冰强结果!=NULL)
		*冰强结果=装备属性强化增加增幅*(当前角色对象->角色属性[DNF角色对象::角色冰属性强化]-当前角色对象->结婚属强-13);
	if (光强结果!=NULL)
		*光强结果=装备属性强化增加增幅*(当前角色对象->角色属性[DNF角色对象::角色光属性强化]-当前角色对象->结婚属强-13);
	if (暗强结果!=NULL)
		*暗强结果=装备属性强化增加增幅*(当前角色对象->角色属性[DNF角色对象::角色暗属性强化]-当前角色对象->结婚属强-13);
}


//DNF杂项数据
//////////////////////////////////////////////////////////////////////////
void DNF计算核心::应用唤醒属性()
{
	当前角色对象->四维增加(335);
	当前角色对象->三攻增加(65);
	当前角色对象->全属强增加(13);
	当前角色对象->全属抗增加(11);
	当前角色对象->暴击增加(PC(8));
	当前角色对象->攻速增加(PC(1));
	当前角色对象->施放加速(PC(1));
	当前角色对象->移速增加(PC(8));
}

//https://dnf.qq.com/cp/a20230921gaebolg/page4.html
float 勋章_品质_攻击强化[6]={103.5,204.5,379.9,596.0,853.2,1168.8};
float 守护珠_品质_攻击强化[5]={22.4,40.3,70.1,114.0,175.3};	//一共4个
float 勋章_强化_攻击强化[13]={0.0,39.0,77.9,116.9,155.8,194.8,233.7,272.7,311.7,350.6,389.6,428.5,467.5};
//int 勋章_品质_名望[6]={235,315,415,509,606,708};
//int 守护珠_品质_名望[5]={46,58,72,88,106};	//一共4个
//int 勋章_强化_名望[13]={0,24,47,71,94,118,142,165,189,212,236,259,283};

void DNF计算核心::应用勋章属性()
{
	//勋章系统基本属性
	当前角色对象->四维增加(48);
	当前角色对象->三攻增加(30);
	当前角色对象->全属强增加(7);
	当前角色对象->暴击增加(PC(1.5));
	当前角色对象->攻速增加(PC(3));
	当前角色对象->施放加速(PC(4.5));
	当前角色对象->移速增加(PC(3));

	//勋章升级强化属性
	int 勋章品质=当前角色对象->勋章品质;
	int 勋章强化=当前角色对象->勋章强化;
	int* 守护珠品质=(int*)当前角色对象->守护珠品质;

	float 勋章系统攻强=勋章_品质_攻击强化[勋章品质]+勋章_强化_攻击强化[勋章强化]+
		守护珠_品质_攻击强化[守护珠品质[0]]+守护珠_品质_攻击强化[守护珠品质[1]]+
		守护珠_品质_攻击强化[守护珠品质[2]]+守护珠_品质_攻击强化[守护珠品质[3]];
	当前角色对象->攻击强化增加(PC(勋章系统攻强));
}

void DNF计算核心::应用结婚属性()
{
	当前角色对象->力智增加(当前角色对象->结婚力智);
	当前角色对象->全属强增加(当前角色对象->结婚属强);
	当前角色对象->物攻增加(当前角色对象->结婚物攻);
	当前角色对象->魔攻增加(当前角色对象->结婚魔攻);
	当前角色对象->独立增加(当前角色对象->结婚独立);
	当前角色对象->攻速增加(当前角色对象->结婚攻速);
	当前角色对象->移速增加(当前角色对象->结婚移速);
	当前角色对象->施放加速(当前角色对象->结婚施放);
}

void DNF计算核心::应用名称装饰卡属性()
{
	当前角色对象->四维增加(当前角色对象->名称装饰卡四维);
	当前角色对象->三速增加(当前角色对象->名称装饰卡三速);
}

int 冒险团等级四维[50]={100,110,125,140,150, 160,170,180,190,200,
	210,220,220,220,220, 230,230,240,240,250,
	250,250,250,250,260, 260,260,260,260,270,
	370,270,270,270,280, 280,280,280,280,290,
	290,290,290,290,290, 290,290,290,290,290};
void DNF计算核心::应用杂项属性()
{
	//公会
	当前角色对象->四维增加(当前角色对象->公会属性四维);	

	//公会训练官
	当前角色对象->力智增加(当前角色对象->公会训练官四维);
	当前角色对象->三攻增加(当前角色对象->公会训练官三攻);
	当前角色对象->三速增加(当前角色对象->公会训练官三速);

	//冒险团
	当前角色对象->四维增加(冒险团等级四维[当前角色对象->冒险团等级]);	

	//无色契约
	当前角色对象->三攻增加(当前角色对象->晶体契约三攻);

	//收集箱
	当前角色对象->三攻增加(当前角色对象->收集箱三攻);
	当前角色对象->四维增加(当前角色对象->收集箱四维);
	当前角色对象->全属强增加(当前角色对象->收集箱属强);
}

void DNF计算核心::应用装备基础属性()
{
	/*
	//https://www.bilibili.com/video/BV1ECiGeUExe
	红皮装备61~80级，每级+10%攻强，共200%攻强（所以跨越之忆武器有100%攻强）
	技攻10级跳一次，每次+1%（辞典中[属性等级适用的技能伤害]）
	红皮60级以下有12%装备技攻（以此为100%，鞋子和护肩技攻不一样）
	红皮60级有12%*1.01=13.1%装备技攻
	红皮70级有12%*1.02=14.2%装备技攻
	红皮80级有12%*1.03=15.4%装备技攻=史诗显示技攻

	上衣下装手镯共享一个高技攻，如果3个部位成长等级不同，适用成长等级最高的
	根据成长等级确定提升率，每10级+3%（辞典中[神界装备专属技能伤害]）
	红皮标1=12%*1
	红皮标10=12%*1.03
	红皮标20=12%*1.06
	红皮标30=12%*1.09
	红皮标40=12%*1.12=25.4%
	红皮标50=12%*1.15=28.8%
	红皮标60=12%*1.01*1.18=33.5%
	红皮标70=12%*1.02*1.21=38.2%
	红皮标80=12%*1.03*1.24=43%=史诗显示技攻

	计算器全部按满级算,不区分110装备基础技攻
	标装备,传说比史诗少了品级的四维,史诗升神后四维进一步增加,需要做出区分
	史诗升神后多了204.8%攻强

	此外,鞋子额外+4移速,腰带额外+3kg负重,右槽辅助属性额外+1级太阳
	*/

	float 装备基础技攻表[装备部位总数]={12, 12, 34, 12, 29, 12, 12, 12, 12, 12, 12};

	//首饰四维不一样,力智分开记录
	float 传说装备力量表[装备部位总数]={140, 140, 132, 124, 124, 147, 100, 172, 146, 171, 171};
	float 传说装备智力表[装备部位总数]={140, 140, 132, 124, 124, 100, 147, 172, 146, 171, 171};
	float 史诗装备力量表[装备部位总数]={142, 142, 134, 125, 125, 151, 100, 176, 150, 175, 175};
	float 史诗装备智力表[装备部位总数]={142, 142, 134, 125, 125, 100, 151, 176, 150, 175, 175};

	for (int i=0;i<装备部位总数;i++)
	{
		if (当前角色对象->部位有装备((DNF装备部位)i))
		{
			//领域之主应用标属性
			if (当前角色对象->角色装备[i]->品质==传说)
			{
				当前角色对象->力量增加(传说装备力量表[i]);
				当前角色对象->智力增加(传说装备智力表[i]);
				当前角色对象->攻击强化增加(PC(200));
			}
			//其余装备均升神,应用神属性
			else
			{
				当前角色对象->力量增加(史诗装备力量表[i]);
				当前角色对象->智力增加(史诗装备智力表[i]);
				当前角色对象->攻击强化增加(PC(204.8));	
			}
			float 技攻=(1.0f+PC(装备基础技攻表[i]))*1.03f-1.0f;
			当前角色对象->技能伤害提升(技攻);
			if (当前职业对象->是辅助职业())
				当前职业对象->技能等级增加(50,50,1,觉醒技能);
		}
	}

	//共享高伤害,在之前基础上乘算
	if (当前角色对象->部位有装备(上衣) || 当前角色对象->部位有装备(手镯) || 当前角色对象->部位有装备(耳环))
	{
		当前角色对象->技能伤害提升(PC(24));
	}

	//鞋子加4移速
	if (当前角色对象->部位有装备(鞋子))
	{
		当前角色对象->移速增加(PC(4));
	}

	//右槽加2级太阳
	if (当前角色对象->部位有装备(右槽))
	{
		if (当前职业对象->是辅助职业())
			当前职业对象->技能等级增加(50,50,1,觉醒技能);
	}
}



void DNF计算核心::应用用户补正属性(BOOL 伤害类补正)
{
	if (伤害类补正)
	{
		当前角色对象->四维增加(当前角色对象->四维补正);
		当前角色对象->三攻增加(当前角色对象->三攻补正);
		当前角色对象->技能伤害提升(当前角色对象->技攻补正);
		当前角色对象->攻击强化增加(当前角色对象->攻击强化补正);
		当前角色对象->攻击强化增幅增加(当前角色对象->攻击强化增幅补正);
		当前角色对象->火强增加(当前角色对象->属强补正[0]);
		当前角色对象->冰强增加(当前角色对象->属强补正[1]);
		当前角色对象->光强增加(当前角色对象->属强补正[2]);
		当前角色对象->暗强增加(当前角色对象->属强补正[3]);
	}
	else
	{
		当前角色对象->火抗增加(当前角色对象->属抗补正[0]);
		当前角色对象->冰抗增加(当前角色对象->属抗补正[1]);
		当前角色对象->光抗增加(当前角色对象->属抗补正[2]);
		当前角色对象->暗抗增加(当前角色对象->属抗补正[3]);
		for (int i=0;i<13;i++)
			当前角色对象->异抗增加((DNF异常状态类型)i,当前角色对象->异抗补正[i]);
		当前角色对象->攻速增加(当前角色对象->攻速补正);
		当前角色对象->技能范围增加(当前角色对象->技能范围补正);
		当前角色对象->MP消耗量增加(当前角色对象->MP消耗量补正);
	}
}

void DNF计算核心::应用药剂属性()
{
	//以下药剂属性均不冲突
	if (当前角色对象->使用药剂[斗神之吼秘药])
		当前角色对象->伤害提升(PC(12));

	if (当前角色对象->使用药剂[顶级力量灵药])
		当前角色对象->力量增加(175);

	if (当前角色对象->使用药剂[顶级智力灵药])
		当前角色对象->智力增加(175);

	if (当前角色对象->使用药剂[赛利亚的特调酷饮])
		当前角色对象->全属强增加(5);

	if (当前角色对象->使用药剂[属性强化药剂])
		当前角色对象->全属强增加(10);

	if (当前角色对象->使用药剂[魔界战力释放秘药])
		当前角色对象->力智增加(150);

	if (当前角色对象->使用药剂[魔界潜力释放秘药])
		当前角色对象->三速增加(PC(10));

	if (当前角色对象->使用药剂[火符咒])
		当前角色对象->火抗增加(30);
	if (当前角色对象->使用药剂[冰符咒])
		当前角色对象->冰抗增加(30);
	if (当前角色对象->使用药剂[光符咒])
		当前角色对象->光抗增加(30);
	if (当前角色对象->使用药剂[暗符咒])
		当前角色对象->暗抗增加(30);
	if (当前角色对象->使用药剂[天空之海符咒])
		当前角色对象->全属抗增加(15);

	if (当前角色对象->使用药剂[强力的神奇针剂])
		当前角色对象->全异抗增加(PC(5));
}

void DNF计算核心::应用系统奶加成()
{
	if (当前角色对象->场景==修炼道场)
		return ;
	//https://baijiahao.baidu.com/s?id=1792702217240425690&wfr=spider&for=pc
	//除了角色基础属性和被动加成，其余所有力智都会计入系统奶
	//修炼道场和团本的系统奶均没有多人组队增伤，按基本公式算即可
	//如果是军团本地图，多人组队且没有辅助时，力智系数和增伤率会随人数变化，但有辅助时仍是基本属性
	//系统奶需取整
	int 力量排除值=0;
	int 智力排除值=0;
	当前职业对象->获取系统奶排除属性值(&力量排除值,&智力排除值);
	if (当前职业对象->攻击类型==物理攻击类型)	//婚戒bug
		力量排除值+=当前角色对象->结婚力智;
	int 力量系统奶=(当前角色对象->角色属性[DNF角色对象::角色力量]-力量排除值)*3.08f+2886;
	int 智力系统奶=(当前角色对象->角色属性[DNF角色对象::角色智力]-智力排除值)*3.08f+2886;
	当前角色对象->力量增加(力量系统奶);
	当前角色对象->智力增加(智力系统奶);
	//UI只显示角色伤害类型对应的系统奶
	if (当前职业对象->攻击类型==物理攻击类型)
		系统奶=力量系统奶;
	else if (当前职业对象->攻击类型==魔法攻击类型)
		系统奶=智力系统奶;
}


enum 规律技能
{
	规律_强力一击,
	规律_冥想,
	规律_魔弹射手,
	规律_魔力增幅,
	规律_预备弹匣,
	规律_乱射,
	规律_魔剑舞者,
	规律_荆棘护甲,
	规律_剑刃帐幕,
	规律_剑痕,
	规律_魔工学炮手,
	规律_核融合	,
	规律_空气力学,
	规律_魔力猎食,
	规律技能数量,
};

enum 猛攻技能
{
	猛攻_强力一击,
	猛攻_冥想,
	猛攻_速攻连击,
	猛攻_速攻奔涌击,
	猛攻_速攻闪影击,
	猛攻_破竹之势,
	猛攻_强袭破击,
	猛攻_强袭强腕击,
	猛攻_强袭泰山击,
	猛攻_英雄豪杰,
	猛攻技能数量,
};

enum 保护技能
{
	保护_强力一击,
	保护_冥想,
	保护_保护罩填充,
	保护_护盾爆裂爆炸,
	保护_火盾,
	保护_背水一战,
	保护_保护罩续充,
	保护_护盾爆裂恢复,
	保护_水盾,
	保护_披靡庇护,
	保护技能数量,
};

enum 具现技能
{
	具现_强力一击,
	具现_冥想,
	具现_灵药炼制,
	具现_力量精通,
	具现_强化力量精通,
	具现_传说再现破坏,
	具现_高效炼制,
	具现_精炼收尾,
	具现_完美炼制,
	具现_一级炼制术士,
	具现_治愈精通,
	具现_强化治愈精通,
	具现_传说再现守护,
	具现技能数量,
};

void DNF计算核心::应用特性技能属性()
{
	//特性技能不限制用户的分支选择，点了就加到属性，忽略特效伤害
	int 特性类型=当前角色对象->特性类型;
	int* 特性等级=当前角色对象->特性等级;

	//固定前2个
	float 强力一击提升表[6]={0,10,16,22,28,35};
	float 冥想提升表[3]={0,10,20};
	当前角色对象->技能伤害提升(PC(强力一击提升表[特性等级[0]]));
	当前职业对象->技能冷却减少(1,100,PC(冥想提升表[特性等级[1]]),主动非觉醒技能);

	if (特性类型==0)
	{
		//规律全是特效，跳过
	}
	else if (特性类型==1)
	{
		//猛攻
		float 猛攻速度表[6]={0, 2, 3, 4, 4.5, 5};
		float 速度1=猛攻速度表[特性等级[猛攻_速攻连击]];
		float 速度2=猛攻速度表[特性等级[猛攻_速攻奔涌击]];
		float 速度3=猛攻速度表[特性等级[猛攻_速攻闪影击]];
		if (特性等级[猛攻_速攻闪影击]!=0)
			速度3+=2;	//0, 4, 5, 6, 6.5, 7
		//即使没满级，也视为全程生效
		当前角色对象->三速增加(PC(速度1+速度2+速度3));
		float 猛攻技伤表[4]={0, 3, 4, 5};
		当前角色对象->技能伤害提升(PC(猛攻技伤表[特性等级[猛攻_破竹之势]]));
		当前角色对象->技能伤害提升(PC(猛攻技伤表[特性等级[猛攻_英雄豪杰]]));
	}
	else if (特性类型==2)
	{
		//保护
		float 保护一觉提升表[6]={0,0,10,15,25,30};
		当前职业对象->技能攻击力增加(50,50,PC(保护一觉提升表[特性等级[保护_背水一战]]),觉醒技能);
		if (特性等级[保护_背水一战]!=0)
			当前职业对象->技能冷却减少(50,50,PC(50),觉醒技能);
		float 保护技伤提升表[8]={0, 0, 0, 0, 0, 0, 0.5, 1.0};
		当前角色对象->技能伤害提升(PC(保护技伤提升表[特性等级[保护_水盾]]));
		float 保护三觉提升表[6]={0,15,17,20,22,25};
		当前职业对象->技能攻击力增加(100,100,PC(保护三觉提升表[特性等级[保护_披靡庇护]]),觉醒技能);
	}
	else if (特性类型==3)
	{
		//具现效果
		//https://zhuanlan.zhihu.com/p/689154303
		//同类灵药不叠加，仅增加时长，不同类可叠加
		//武具之间不可叠加，强化的武具是5技攻+5三速
		//直接应用最高属性，不求期望
		if (特性等级[具现_灵药炼制]!=0)
		{
			当前角色对象->技能伤害提升(PC(5));
			当前角色对象->三速增加(PC(20));
		}
		float 力量精通表[8]={0, 1, 1, 1, 1, 1, 1.5, 2};
		当前角色对象->技能伤害提升(PC(力量精通表[特性等级[具现_力量精通]]));
		if (特性等级[具现_强化力量精通]!=0)
			当前角色对象->三速增加(PC(5));
		int 武具等级=max(特性等级[具现_传说再现破坏],特性等级[具现_传说再现守护]);
		if (武具等级>0 && 武具等级<=5)
		{
			当前角色对象->技能伤害提升(PC(4));
			当前角色对象->三速增加(PC(5));
		}
		else if (武具等级>5)
		{
			当前角色对象->技能伤害提升(PC(5));
			当前角色对象->三速增加(PC(5));
		}
	}
}












//计算核心计算框架
//////////////////////////////////////////////////////////////////////////

void DNF计算核心::初始化()
{

}

void DNF计算核心::反初始化()
{

}

void DNF计算核心::重置()
{
	for (int i=0;i<属性结果总数;i++)
		属性结果[i]=0;

	总伤害=0;
	系统奶=0;

	技能结果数=0;
	for (int i=0;i<技能结果数;i++)
	{
		技能结果[i].技能索引=0;
		技能结果[i].技能等级=0;
		技能结果[i].技能次数=0;
		技能结果[i].技能冷却时间=0;
		技能结果[i].技能平均伤害=0;
		技能结果[i].技能总伤害=0;
		技能结果[i].技能占比=0;
	}

	技能冷却结果数=0;
	for (int i=0;i<技能冷却结果数;i++)
	{
		技能冷却结果[i].技能索引=0;
		技能冷却结果[i].技能原始时间=0;
		技能冷却结果[i].技能当前时间=0;
		技能冷却结果[i].技能缩减率=0;
		技能冷却结果[i].技能无色数=0;
	}

	被动技能数=0;
	for (int i=0;i<被动技能数;i++)
	{
		被动技能结果[i].技能索引=0;
		被动技能结果[i].技能等级=0;
	}

	for (int i=0;i<全部装备部位总数;i++)
	{
		装备结果[i].打造物攻加成=0;
		装备结果[i].打造魔攻加成=0;
		装备结果[i].打造独立加成=0;
		装备结果[i].打造四维加成=0;
		装备结果[i].锻造独立加成=0;
		装备结果[i].满足条件=TRUE;
		wcscpy(装备结果[i].条件描述,L" ");
	}
}

void DNF计算核心::生成部位条件触发结果(int 部位)
{
	if (当前角色对象->条件数量==0)
	{
		装备结果[部位].满足条件=TRUE;
		wcscpy(装备结果[部位].条件描述,L" ");
	}
	else if (当前角色对象->条件数量==当前角色对象->条件满足数量)
	{
		装备结果[部位].满足条件=TRUE;
		swprintf(装备结果[部位].条件描述,L"满足条件: (%d/%d)",当前角色对象->条件满足数量,当前角色对象->条件数量);
	}
	else
	{
		装备结果[部位].满足条件=FALSE;
		swprintf(装备结果[部位].条件描述,L"不满足条件: (%d/%d)",当前角色对象->条件满足数量,当前角色对象->条件数量);
	}
	当前角色对象->重置条件信息();
}

void DNF计算核心::主动技能无色数调整()
{
	if (当前角色对象->部位穿戴装备检查(腰带,L"恐惧缠绕腰带"))
	{
		for (int i=0;i<当前职业对象->主动技能数量;i++)
		{
			if (当前职业对象->技能无色数量[i]==0)
				当前职业对象->技能无色数量[i]+=2;
		}
	}
	if (当前角色对象->部位穿戴装备检查(耳环,L"堕落的灵魂"))
	{
		for (int i=0;i<当前职业对象->主动技能数量;i++)
		{
			if (当前职业对象->技能无色数量[i]!=0)
				当前职业对象->技能无色数量[i]+=2;
		}
	}
	if (当前角色对象->部位穿戴装备检查(手镯,L"自由之缚手镯"))
	{
		for (int i=0;i<当前职业对象->主动技能数量;i++)
		{
			当前职业对象->技能无色数量[i]*=8;
			if (当前职业对象->技能无色数量[i]>16)
				当前职业对象->技能无色数量[i]=16;
		}
	}
}

void DNF计算核心::应用黎明圣杯加成()
{
	for (int i=0;i<当前职业对象->主动技能数量;i++)
	{
		int 方向键数量=当前角色对象->技能手搓方向键数量[i];
		float 黎明圣杯倍率=1.0f;
		if (方向键数量==1)
			黎明圣杯倍率=1.07f;
		else if (方向键数量==2)
			黎明圣杯倍率=1.09f;
		else if (方向键数量==3)
			黎明圣杯倍率=1.11f;
		else if (方向键数量==4)
			黎明圣杯倍率=1.15f;
		当前职业对象->技能手搓伤害倍率[i]*=黎明圣杯倍率;
	}
}

void DNF计算核心::应用剑帝副武器加成()
{
	//增幅力量不计入
	int 强化等级=当前角色对象->副武器强化;
	int 副武器物攻=0;
	int 副武器力量=0;
	if (当前角色对象->副武器状态==1)	//普通史诗
	{
		副武器物攻+=125;
		副武器力量+=8;
		副武器物攻+=计算武器强化物攻(强化等级,史诗,武器_光剑)*0.1f;
	}
	else if (当前角色对象->副武器状态==1)	//雾神20史诗
	{
		副武器物攻+=126;
		副武器力量+=8;
		副武器物攻+=计算武器强化物攻(强化等级,史诗Plus,武器_光剑)*0.1f;
	}
	else if (当前角色对象->副武器状态==1)	//普通太初
	{
		副武器物攻+=129;
		副武器力量+=9;
		副武器物攻+=计算武器强化物攻(强化等级,太初Lite,武器_光剑)*0.1f;
	}
	else if (当前角色对象->副武器状态==1)	//雾神20太初
	{
		副武器物攻+=130;
		副武器力量+=9;
		副武器物攻+=计算武器强化物攻(强化等级,太初,武器_光剑)*0.1f;
	}
	当前角色对象->物攻增加(副武器物攻);
	当前角色对象->力量增加(副武器力量);
}

void DNF计算核心::应用星辰百变套装属性()
{
	if (当前角色对象->星辰百变数量>=2)
	{
		当前角色对象->技能伤害提升(PC(3));
		if (当前职业对象->是辅助职业())
			当前角色对象->技能范围增加(PC(20));
	}
	if (当前角色对象->星辰百变数量>=4)
	{
		当前角色对象->移速增加(PC(15));
		if (当前职业对象->是辅助职业())
			当前角色对象->技能范围增加(PC(10));
	}
}

void DNF计算核心::应用装备强化增幅锻造属性()
{
	//逐个部位计算强化增幅数据锻造，放到结果一份，然后加到角色属性一份
	for (int i=0;i<装备部位总数;i++)
	{
		if (当前角色对象->角色装备[i]->空装备)
			continue;
		int 品质=当前角色对象->角色装备[i]->品质;
		int 强化等级=当前角色对象->装备强化等级[i];
		BOOL 增幅类型=当前角色对象->装备强化类型[i];
		int 等级=105;
		float 增幅属性值=0.0f;
		装备结果[i].打造四维加成=0;
		if (i==左槽 || i==右槽)
		{
			//强化就有的属性（四维）
			装备结果[i].打造四维加成=计算左右槽强化额外四维(强化等级,品质);
			当前角色对象->四维增加(装备结果[i].打造四维加成);
			//增幅额外加的属性（单属性）
			if (增幅类型)
				增幅属性值=计算增幅四维(强化等级,品质);
		}
		else if (i==耳环)
		{
			//耳环强化有三攻
			装备结果[i].打造物攻加成=计算耳环强化三攻(强化等级,品质);
			装备结果[i].打造魔攻加成=装备结果[i].打造物攻加成;
			装备结果[i].打造独立加成=装备结果[i].打造物攻加成;
			当前角色对象->三攻增加(装备结果[i].打造物攻加成);
			if (增幅类型)
				增幅属性值=计算增幅四维(强化等级,品质);
		}
		else
		{
			//其余部位增幅才有属性
			if (增幅类型)
				增幅属性值=计算增幅四维(强化等级,品质);
		}
		装备结果[i].打造四维加成+=增幅属性值;	//与左右槽的合并
		//注意增幅是单项属性加成，不是四维，自动选取职业对应属性
		if (当前职业对象->攻击类型==物理攻击类型)
			当前角色对象->力量增加(增幅属性值);
		else if (当前职业对象->攻击类型==魔法攻击类型)
			当前角色对象->智力增加(增幅属性值);
	}
	if (当前角色对象->武器动态对象->空装备==FALSE)
	{
		int 品质=当前角色对象->武器动态对象->品质;
		DNF武器类型 武器类型=当前角色对象->武器动态对象->武器类型;
		int 强化等级=当前角色对象->装备强化等级[武器];
		int 锻造等级=当前角色对象->武器锻造等级;
		BOOL 增幅类型=当前角色对象->装备强化类型[武器];
		int 等级=105;	
		装备结果[武器].打造物攻加成=计算武器强化物攻(强化等级,品质,武器类型);
		装备结果[武器].打造魔攻加成=计算武器强化魔攻(强化等级,品质,武器类型);
		装备结果[武器].锻造独立加成=计算武器锻造独立(锻造等级,品质,武器类型);
		if (增幅类型)
			装备结果[武器].打造四维加成=计算增幅四维(强化等级,品质);
		当前角色对象->物攻增加(装备结果[武器].打造物攻加成);
		当前角色对象->魔攻增加(装备结果[武器].打造魔攻加成);
		当前角色对象->独立增加(装备结果[武器].锻造独立加成);
		if (当前职业对象->攻击类型==物理攻击类型)
			当前角色对象->力量增加(装备结果[武器].打造四维加成);
		else if (当前职业对象->攻击类型==魔法攻击类型)
			当前角色对象->智力增加(装备结果[武器].打造四维加成);
		//只给辅助职业加，注意是四维不是独立，结果与增幅合并
		int 武器锻造四维=计算辅助武器锻造四维(锻造等级,品质,武器类型);
		当前角色对象->四维增加(武器锻造四维);
		装备结果[武器].打造四维加成+=武器锻造四维;
	}
}

float 怪物防御数据[12]={
	//沙袋		巴卡尔		雾神			挑战沙袋
	29.4478,	152.3267,	152.3267,	1453.9578,	//修炼道场
	1139.0456,	6055.0264,	6055.0264,	0,			//巴卡尔攻坚战
	2277.3948,	12126.9145,	12126.9145,	0,			//雾神攻坚战
};

float DNF计算核心::获取怪物防御系数(int* 属抗)
{
	//怪物防御力和怪物有关，根据场景防御参数通过公式加算求出
	//由于减防装备删除，无法再测出防御，直接改用防御率，测出每个场景下怪物的防御率
	int 场景索引=当前角色对象->场景;
	int 怪物索引=当前角色对象->怪物;
	float 防御系数=怪物防御数据[场景索引*4+怪物索引];
	if (怪物索引==爆龙王巴卡尔 || 怪物索引==雾神雾)
	{
		if (属抗!=NULL)
			*属抗=20;
	}
	return 防御系数;
}

float DNF计算核心::异常保有率计算(int 类型)
{
	//https://www.bilibili.com/opus/845672201551085577
	//参考影天的公式说明，代码几乎照搬纸飞机

	DNF角色对象::异常触发记录* 异常属性=当前角色对象->异常属性;
	if (类型==异常状态总数+1)	//灼伤破冰
	{
		float 冰冻CD=异常属性[冰冻].触发频率;
		if (当前角色对象->穿戴装备检查(L"信守誓约的步伐")==FALSE)
			冰冻CD=max(3,冰冻CD);
		if (当前角色对象->适用控制型异常)
			冰冻CD=min(异常属性[冰冻].触发频率,冰冻CD);
		float 灼伤时间=5*(1.0+异常属性[灼伤].持续时间百分比增加量)+异常属性[灼伤].持续时间增加量;
		return max(1 - (2*冰冻CD + 1) / (4*灼伤时间),0);
	}
	else
	{
		float 持续时间=0;
		if (类型==出血)
			持续时间=3*(1.0+异常属性[出血].持续时间百分比增加量)+异常属性[出血].持续时间增加量;
		else if (类型==中毒)
			持续时间=5*(1.0+异常属性[中毒].持续时间百分比增加量)+异常属性[中毒].持续时间增加量;
		else if (类型==灼伤)
			持续时间=5*(1.0+异常属性[灼伤].持续时间百分比增加量)+异常属性[灼伤].持续时间增加量;
		else if (类型==感电)
			持续时间=10*(1.0+异常属性[感电].持续时间百分比增加量)+异常属性[感电].持续时间增加量;
		float 异常CD=异常属性[类型].触发频率;
		if (当前角色对象->穿戴装备检查(L"承诺誓约的腰带"))
			异常CD=max(0.5,异常CD);
		return max(1 - (2*异常CD + 1) / (4*持续时间),0);
	}
}

void DNF计算核心::异常系数计算(float* 异常伤害系数)
{
	//https://bbs.colg.cn/thread-9131958-1-1.html
	//总伤害=直伤*(1-异常占比)+直伤*异常占比*装备基础增伤*层数增伤
	//其中异常伤害可能受结算频率影响，前面部分吃不到某些装备提供的特殊增伤，引入保有率概念
	//保有率系数=(保有率*装备特殊增伤*破冰增伤)+(1-保有率) 
	//总伤害=直伤部分+异常伤害部分*保有率系数
	DNF角色对象::异常触发记录* 异常属性=当前角色对象->异常属性;
	for (int i=0;i<4;i++)
	{
		//装备提供的异常伤害增加词条
		float 装备基础增伤倍率=异常属性[i].伤害增加量+1.0f;

		//层数提升，第一层只保证有异常伤害，叠更多层才有增伤
		float 异常类型提升率;
		if (i==出血)
			异常类型提升率=1.0f+(当前角色对象->出血层数-1)*PC(1);
		else if (i==中毒)
			异常类型提升率=1.0f+(当前角色对象->中毒层数-1)*PC(2);
		else if (i==感电)
			异常类型提升率=1.0f+(当前角色对象->感电层数-1)*PC(0.5);
		else if (i==灼伤)
			异常类型提升率=1.0f;

		//存在破冰时，或带了立即结算并增伤的装备时，需要计算保有率
		//否则仅在结算速度上有区别，不会丢伤害
		float 保有率=1.0f;
		float 装备特殊增伤倍率=1.0f;
		if (异常属性[i].伤害占比!=0)
		{
			//灼伤占比不为0时，一定存在灼伤状态，只要同时存在冰冻就可能触发破冰
			//冰冻是控制型异常，破韧后才会触发，或带腰带才会触发
			if ((i==灼伤 && 异常属性[冰冻].触发频率<999) && 
				(当前角色对象->适用控制型异常 || 当前角色对象->穿戴装备检查(L"永眠前的准备")))
			{
				装备特殊增伤倍率=(1.0f+当前角色对象->破冰增伤增加量)*1.1f;
				保有率=异常保有率计算(异常状态总数+1);
			}
			else if (当前角色对象->穿戴装备检查(L"永眠前的准备"))
			{
				//只有这一件立即结算并增伤的装备，不再单独定义记录字段
				装备特殊增伤倍率=1.1f;
				保有率=异常保有率计算(i);
			}
		}
		异常伤害系数[i]=装备基础增伤倍率*异常类型提升率*((1-保有率)+保有率*装备特殊增伤倍率);
	}
}




void DNF计算核心::执行计算()
{
	//切换职业时，调用CalcCoreChangeJob()将[伤害结果]设为Invalid，并变更和重置职业对象
	//随后加载职业设置，重置[角色对象]，对每项设置调用UpdateSettingToCalcModule()更新到计算模块的[角色对象]
	//加载结束，UI模块重置界面，并调用SubmitSettingChange()执行第一次计算，由CalcCoreDoCalculation()负责进入计算模块
	//第一次计算后，[伤害结果]变为Valid，UpdateCalcResult()将结果更新到UI
	//或是每次设置变更后，也会执行UpdateSettingToCalcModule()+SubmitSettingChange()的序列

	//CalcCoreDoCalculation()会先调用 计算核心.执行计算()，传入[角色对象]
	//[计算核心]依照相关规则，操作[角色对象]，统计数据，计算伤害，生成计算结果和需要显示的内容
	//CalcCoreDoCalculation()取出相关内容，复制到[伤害结果]，[伤害结果]进行排序，剩下的事情交给UI处理

	auto 非空对象应用属性=[](DNF装备对象* 对象)->void
	{
		if (对象->空装备==FALSE)
			对象->应用属性();
	};

	auto 非空对象统计属性=[](DNF装备对象* 对象)->void
	{
		if (对象->空装备==FALSE)
			对象->统计属性();
	};

	//大部分属性都不受属性的条件影响，可直接加入，无需统计
	//装备需要先统计相关条件，再应用属性，辟邪玉属强和系统奶需要统计完所有属性，最后加入
	//提供3个特殊标记，一个控制是否为装备加成，一个控制冷却统计加入面板，一个控制攻速鞋是否适用攻速
	//应用附魔属性前，逐个部位检查装备，如果影响附魔，添加属性前设置倍率，添加后还原
	//技能消耗无色数特殊处理
	
	//初始化本次计算
	当前角色对象->重置属性();
	当前职业对象->重置属性();

	//应用基本属性和固定属性
	当前职业对象->应用职业基本属性();
	当前职业对象->应用职业防具精通属性();
	应用唤醒属性();
	应用结婚属性();
	当前角色对象->攻速鞋部位标记=L"勋章";
	应用勋章属性();
	当前角色对象->攻速鞋部位标记=L"名称装饰卡";
	应用名称装饰卡属性();
	当前角色对象->攻速鞋部位标记=L"其他部位";
	应用杂项属性();	
	应用药剂属性();
	
	//装备强化增幅锻造相关，计算后一份加到属性，一份提交到结果
	应用装备强化增幅锻造属性();

	//副武器（不计入强化数值）
	if (当前职业对象->职业==职业_流浪武士)
		应用剑帝副武器加成();

	//附魔，徽章，装扮，特色装备，辟邪玉，应该都属于装备加成
	//比如宠物装备的MP消耗量就计入
	//另外没穿戴装备时，不计算附魔与徽章
	当前角色对象->装备加成开关=TRUE;

	//附魔
	//附魔除了武器，其余部位的附魔均不加攻速，攻速鞋标记保持"其他部位"即可
	//附魔类装备需要调整倍率，部位处理完以后还原
	WCHAR* 附魔加倍装备[拓展装备部位总数]={L"白金流光夹克",L"白虹贯日长裤",L"白色的信念斗篷",L"白玉无邪腰带",L"白色秘境皮鞋",
		L"第二个黑桃-权威",L"第一个黑桃-贵族",L"第三个黑桃-死亡",L"命运的魔法箱",L"虚伪之石",L"时间之念耳环",NULL,NULL,NULL};
	for (int i=0;i<拓展装备部位总数;i++)
	{
		if (当前角色对象->部位有装备((DNF装备部位)i)==FALSE)
			continue;
		if (当前角色对象->部位穿戴装备检查(i,附魔加倍装备[i]))
			当前角色对象->附魔倍率=2.0f;

		//虽然武器使用单独的对象，但是武器附魔还是放在一起处理
		非空对象应用属性(当前角色对象->角色附魔[i]);

		当前角色对象->附魔倍率=1.0f;
		当前角色对象->攻速鞋部位标记=L"其他部位";
	}

	//徽章
	当前角色对象->攻速鞋部位标记=L"徽章";
	for (int i=0;i<装备部位总数-1;i++)	//没有耳环
	{
		if (当前角色对象->部位有装备((DNF装备部位)i)==FALSE)
			continue;
		非空对象应用属性(当前角色对象->角色徽章1[i]);
	}		
	for (int i=0;i<装备部位总数-3;i++)	//没有左右槽和耳环
	{
		if (当前角色对象->部位有装备((DNF装备部位)i)==FALSE)
			continue;
		非空对象应用属性(当前角色对象->角色徽章2[i]);
	}
	for (int i=0;i<2;i++)
	{
		非空对象应用属性(当前角色对象->武器装扮徽章[i]);
		非空对象应用属性(当前角色对象->皮肤徽章[i]);
		非空对象应用属性(当前角色对象->光环徽章[i]);
	}
	当前角色对象->攻速鞋部位标记=L"其他部位";

	//装扮
	当前角色对象->攻速鞋部位标记=L"装扮";
	当前角色对象->装扮动态对象->应用属性();
	当前角色对象->攻速鞋部位标记=L"其他部位";

	//特色装备
	非空对象应用属性(当前角色对象->武器装扮);
	非空对象应用属性(当前角色对象->皮肤);
	非空对象应用属性(当前角色对象->光环);
	当前角色对象->攻速鞋部位标记=L"宠物装备";
	非空对象应用属性(当前角色对象->红色宠物装备);
	非空对象应用属性(当前角色对象->蓝色宠物装备);
	非空对象应用属性(当前角色对象->绿色宠物装备);
	当前角色对象->攻速鞋部位标记=L"其他部位";
	当前角色对象->攻速鞋部位标记=L"快捷栏装备";
	非空对象应用属性(当前角色对象->快捷栏装备);
	当前角色对象->攻速鞋部位标记=L"其他部位";

	//辟邪玉大部分加成（速度影响攻速鞋，要在装备之前添加）
	当前角色对象->攻速鞋部位标记=L"辟邪玉";
	当前角色对象->辟邪玉动态对象->应用属性();
	当前角色对象->攻速鞋部位标记=L"其他部位";


	//装备

	//无色装备条件处理
	主动技能无色数调整();

	//在应用装备伤害属性之前，把条件类的补正加入
	应用用户补正属性(FALSE);

	//110装备基本属性，武器除外
	应用装备基础属性();

	//武器基础属性，加的攻速需要进行状态屏蔽（武器的基础冷却不计入面板）
	当前角色对象->面板冷却统计开关=FALSE;
	if (当前角色对象->武器动态对象->空装备==FALSE)
		当前角色对象->武器动态对象->应用基础属性();
	当前角色对象->面板冷却统计开关=TRUE;

	//第一遍统计条件属性加成，武器贴膜和武器加的攻速需要进行状态屏蔽
	for (int i=0;i<全部装备部位总数;i++)
	{
		当前角色对象->攻速鞋部位标记=L"装备和贴膜";	//宠物称号都计入攻速鞋
		if (i==武器)
		{
			当前角色对象->攻速鞋部位标记=L"武器";
			if (当前角色对象->武器动态对象->空装备==FALSE)
				当前角色对象->武器动态对象->统计属性();
		}
		else if (i==武器贴膜)
		{
			if (当前角色对象->使用武器贴膜)
			{
				当前角色对象->攻速鞋部位标记=L"武器贴膜";	
				非空对象统计属性(当前角色对象->武器融合词条[0]);
				非空对象统计属性(当前角色对象->武器融合词条[1]);
				非空对象统计属性(当前角色对象->武器融合词条[2]);
			}
		}
		else if ((i==左槽贴膜 || i==右槽贴膜 || i==耳环贴膜) && 当前角色对象->角色装备[i]->品质==传说)
		{
			//传说贴膜直接调用词条对象
			int 索引=i-左槽贴膜;
			非空对象统计属性(当前角色对象->传说融合词条[索引*3+0]);
			非空对象统计属性(当前角色对象->传说融合词条[索引*3+1]);
			非空对象统计属性(当前角色对象->传说融合词条[索引*3+2]);
		}
		else
		{
			if (当前角色对象->角色装备[i]->空装备==FALSE)
			{
				if (当前角色对象->角色装备[i]->装备细分类型==自定义装备)
				{
					//自定义装备统计属性
					int 索引=i-上衣;
					非空对象统计属性(当前角色对象->角色装备词条1[索引]);
					非空对象统计属性(当前角色对象->角色装备词条2[索引]);
					非空对象统计属性(当前角色对象->角色装备词条3[索引]);
					非空对象统计属性(当前角色对象->角色装备词条4[索引]);
				}
				else
				{
					//固定装备统计属性
					当前角色对象->角色装备[i]->统计属性();
				}
				//套装数量统计
				int 套装索引=当前角色对象->角色装备[i]->套装索引;
				if (套装索引!=-1)
					当前角色对象->套装数量记录[套装索引]++;
			}
		}
		当前角色对象->攻速鞋部位标记=L"其他部位";
	}

	//统计条件时也统计了套装部位数量，然后统计套装的条件属性加成
	//套装对象固定，不会是空对象，内部会判断[套装数量记录]
	//套装对象不记录条件触发情况
	for (int i=0;i<套装总数;i++)
	{
		if (当前角色对象->套装数量记录[i]!=0)
			当前角色对象->套装对象[i]->统计属性();
	}

	//条件和伤害合并到一起了，在计算伤害之前调用
	应用星辰百变套装属性();
	
	float 攻强成长倍率_固定装备=攻强成长神60/攻强成长标80;
	float 攻强成长倍率_自定义装备=1.0f;
	float 攻强成长倍率_领域之主装备=攻强成长标80/攻强成长神60;
	float 攻强成长倍率_贴膜=1.0f;
	//第二遍应用伤害属性，需要根据部位和装备类型设置攻强成长倍率，以装备辞典显示的为基准
	for (int i=0;i<全部装备部位总数;i++)
	{
		if (i==武器)
		{
			if (当前角色对象->武器动态对象->空装备==FALSE)
			{
				//武器的判断比较复杂，由对象自身决定是否调用自定义词条对象
				当前角色对象->装备攻强成长倍率=当前角色对象->武器动态对象->攻强成长倍率;
				当前角色对象->武器动态对象->应用属性();
			}
			当前角色对象->装备攻强成长倍率=1.0f;
		}
		else if (i==武器贴膜)
		{
			当前角色对象->装备攻强成长倍率=1.0f;
			非空对象应用属性(当前角色对象->武器融合词条[0]);
			非空对象应用属性(当前角色对象->武器融合词条[1]);
			非空对象应用属性(当前角色对象->武器融合词条[2]);
		}
		else if ((i==左槽贴膜 || i==右槽贴膜 || i==耳环贴膜) && 当前角色对象->角色装备[i]->品质==传说)
		{
			//传说贴膜直接调用词条对象
			当前角色对象->装备攻强成长倍率=1.0f;
			int 索引=i-左槽贴膜;
			非空对象应用属性(当前角色对象->传说融合词条[索引*3+0]);
			非空对象应用属性(当前角色对象->传说融合词条[索引*3+1]);
			非空对象应用属性(当前角色对象->传说融合词条[索引*3+2]);
		}
		else
		{
			if (当前角色对象->角色装备[i]->空装备==FALSE)
			{
				if (当前角色对象->角色装备[i]->装备细分类型==自定义装备)
				{
					if (当前角色对象->角色装备[i]->品质==传说)
						当前角色对象->装备攻强成长倍率=攻强成长倍率_领域之主装备;
					else
						当前角色对象->装备攻强成长倍率=攻强成长倍率_自定义装备;
					//自定义装备的核心，应用词条的伤害属性
					int 索引=i-上衣;
					非空对象应用属性(当前角色对象->角色装备词条1[索引]);
					非空对象应用属性(当前角色对象->角色装备词条2[索引]);
					非空对象应用属性(当前角色对象->角色装备词条3[索引]);
					非空对象应用属性(当前角色对象->角色装备词条4[索引]);
				}
				else
				{
					if (当前角色对象->角色装备[i]->装备细分类型==固定装备)
						当前角色对象->装备攻强成长倍率=攻强成长倍率_固定装备;
					else
						当前角色对象->装备攻强成长倍率=攻强成长倍率_贴膜;
					//固定装备的核心，真正添加装备伤害属性
					当前角色对象->角色装备[i]->应用属性();
				}
			}
			当前角色对象->装备攻强成长倍率=1.0f;
		}
		//装备条件触发文本（不实现，时间不够，UI也没地方放下多行条件）
		//初始化重置一次，然后每部位记录完都会重置，下一轮开始时仍是重置状态
		生成部位条件触发结果(i);
	}

	//应用套装伤害属性
	for (int i=0;i<套装总数;i++)
	{
		if (当前角色对象->套装数量记录[i]!=0)
			当前角色对象->套装对象[i]->应用属性();
	}

	//装备特殊处理
	//如果还有其他需要特殊处理的装备，继续补加
	if (当前角色对象->部位穿戴装备检查(左槽,L"黎明圣杯"))
		应用黎明圣杯加成();

	当前角色对象->装备加成开关=FALSE;


	//被动要在所有技能等级加成统计完再算，但是可能加力智，要在系统奶前面应用
	//职业对象会根据技能等级是否为0，决定是否应用被动技能，外部不用判断
	当前角色对象->面板冷却统计开关=FALSE;
	for (int i=0;i<当前职业对象->被动技能数量;i++)
		当前职业对象->应用被动技能(当前职业对象->被动技能索引+i);
	当前角色对象->面板冷却统计开关=TRUE;

	//特性技能的技伤和冷却都会加面板
	应用特性技能属性();

	//辟邪玉属强加成
	int 辟邪玉火属强=0;
	int 辟邪玉冰属强=0;
	int 辟邪玉光属强=0;
	int 辟邪玉暗属强=0;
	当前角色对象->辟邪玉动态对象->计算辟邪玉属强加成(&辟邪玉火属强,&辟邪玉冰属强,&辟邪玉光属强,&辟邪玉暗属强);
	当前角色对象->火强增加(辟邪玉火属强);
	当前角色对象->冰强增加(辟邪玉冰属强);
	当前角色对象->光强增加(辟邪玉光属强);
	当前角色对象->暗强增加(辟邪玉暗属强);

	//会同时更新结果的系统奶
	应用系统奶加成();

	//伤害类补正不受任何设置项影响
	当前角色对象->角色属性[DNF角色对象::角色物理攻击力]*=当前角色对象->物攻百分比提升率;
	当前角色对象->角色属性[DNF角色对象::角色魔法攻击力]*=当前角色对象->魔攻百分比提升率;
	当前角色对象->角色属性[DNF角色对象::角色独立攻击力]*=当前角色对象->独立百分比提升率;
	应用用户补正属性(TRUE);


	//数据累积完毕，套用公式计算

	//直伤计算
	int 怪物属抗=0;
	float 防御系数=获取怪物防御系数(&怪物属抗);
	float 攻击强化=当前角色对象->角色属性[DNF角色对象::角色攻击强化];
	float 攻击强化增幅=当前角色对象->角色属性[DNF角色对象::角色攻击强化增幅];
	float 攻强伤害倍率=攻击强化*(1.0f+攻击强化增幅)+1.0f;
	float 属强伤害倍率=(当前角色对象->获取最高属强()-怪物属抗)*0.0045+1.05;
	//由于没有百分比力智提升，无需取整
	float 力智伤害倍率=1.0f;
	if (当前职业对象->攻击类型==物理攻击类型)
		力智伤害倍率=当前角色对象->角色属性[DNF角色对象::角色力量]*0.004+1.0;
	else if (当前职业对象->攻击类型==魔法攻击类型)
		力智伤害倍率=当前角色对象->角色属性[DNF角色对象::角色智力]*0.004+1.0;
	float 角色属性技能伤害=当前角色对象->角色属性[DNF角色对象::角色技能伤害];
	//三攻取整
	int 物理攻击力=当前角色对象->角色属性[DNF角色对象::角色物理攻击力];
	int 魔法攻击力=当前角色对象->角色属性[DNF角色对象::角色魔法攻击力];
	int 独立攻击力=当前角色对象->角色属性[DNF角色对象::角色独立攻击力];
	int 最终攻击力=0;
	if (当前职业对象->是否固伤)
		最终攻击力=独立攻击力;
	else if (当前职业对象->攻击类型==物理攻击类型)
		最终攻击力=物理攻击力;
	else if (当前职业对象->攻击类型==魔法攻击类型)
		最终攻击力=魔法攻击力;

	double 直伤伤害=当前角色对象->增伤倍率*角色属性技能伤害*攻强伤害倍率*属强伤害倍率*力智伤害倍率*最终攻击力;
	直伤伤害/=防御系数;

	//异常伤害计算
	float 异常伤害系数[4];
	异常系数计算(异常伤害系数);
	//异常比例分配
	DNF角色对象::异常触发记录* 异常属性=当前角色对象->异常属性;
	double 出血伤害=直伤伤害*异常属性[出血].伤害占比*异常伤害系数[出血];
	double 中毒伤害=直伤伤害*异常属性[中毒].伤害占比*异常伤害系数[中毒];
	double 感电伤害=直伤伤害*异常属性[感电].伤害占比*异常伤害系数[感电];
	double 灼伤伤害=直伤伤害*异常属性[灼伤].伤害占比*异常伤害系数[灼伤];
	直伤伤害*=1.0f-异常属性[出血].伤害占比-异常属性[中毒].伤害占比-异常属性[感电].伤害占比-异常属性[灼伤].伤害占比;

	double 角色伤害倍率=直伤伤害+出血伤害+中毒伤害+感电伤害+灼伤伤害;
	角色伤害倍率*=1.5*0.001;	//暴击和伤害压缩，破招未计入

	//技能计算
	//主动技能以次数判断是否使用
	for (int i=0;i<当前职业对象->主动技能数量;i++)
	{
		if (当前角色对象->技能次数[i]!=0)
		{
			//这个技能索引很迷糊，开始设计的是技能对象的加入可能顺序变化，和定义顺序不一定一致，所以操作之前先获取索引
			//实际发现是搬石砸脚，自己写的程序，怎么可能顺序变化，定死顺序操作最简单
			int 技能索引=当前职业对象->职业技能列表[i]->索引;
			技能结果[技能结果数].技能索引=技能索引;
			技能结果[技能结果数].技能等级=当前职业对象->计算技能等级(技能索引);
			技能结果[技能结果数].技能次数=当前角色对象->技能次数[i];
			技能结果[技能结果数].技能冷却时间=当前职业对象->计算技能最终冷却(i);
			技能结果[技能结果数].技能总伤害=当前职业对象->计算技能总伤害(i)*角色伤害倍率;
			技能结果[技能结果数].技能平均伤害=技能结果[技能结果数].技能总伤害/当前角色对象->技能次数[i];
			总伤害+=技能结果[技能结果数].技能总伤害;
			技能结果数++;
		}
	}
	for (int i=0;i<技能结果数;i++)
		技能结果[i].技能占比=技能结果[i].技能总伤害/总伤害;
	//冷却全都要算
	技能冷却结果数=当前职业对象->主动技能数量;
	for (int i=0;i<技能冷却结果数;i++)
	{		
		int 技能索引=当前职业对象->职业技能列表[i]->索引;
		技能冷却结果[i].技能索引=技能索引;
		技能冷却结果[i].技能原始时间=当前职业对象->职业技能列表[i]->冷却时间;
		技能冷却结果[i].技能当前时间=当前职业对象->计算技能最终冷却(i);
		技能冷却结果[i].技能缩减率=技能冷却结果[i].技能当前时间/技能冷却结果[i].技能原始时间;
		技能冷却结果[i].技能无色数=当前职业对象->技能无色数量[i];
	}
	//被动全部列出来，不隐藏0级的
	被动技能数=当前职业对象->被动技能数量;
	for (int i=0;i<被动技能数;i++)
	{
		int 技能索引=当前职业对象->职业技能列表[当前职业对象->被动技能索引+i]->索引;
		被动技能结果[i].技能索引=技能索引;
		被动技能结果[i].技能等级=当前职业对象->计算技能等级(技能索引);
	}

	//生成角色属性结果
	属性结果[_物理攻击力]=当前角色对象->角色属性[DNF角色对象::角色物理攻击力]*(1.0f+当前角色对象->角色属性[DNF角色对象::角色旧_三攻增加]);
	属性结果[_魔法攻击力]=当前角色对象->角色属性[DNF角色对象::角色魔法攻击力]*(1.0f+当前角色对象->角色属性[DNF角色对象::角色旧_三攻增加]);
	属性结果[_独立攻击力]=当前角色对象->角色属性[DNF角色对象::角色独立攻击力]*(1.0f+当前角色对象->角色属性[DNF角色对象::角色旧_三攻增加]);
	属性结果[_力量]=当前角色对象->角色属性[DNF角色对象::角色力量]*(1.0f+当前角色对象->角色属性[DNF角色对象::角色旧_力智增加]);
	属性结果[_智力]=当前角色对象->角色属性[DNF角色对象::角色智力]*(1.0f+当前角色对象->角色属性[DNF角色对象::角色旧_力智增加]);
	属性结果[_攻击强化]=当前角色对象->角色属性[DNF角色对象::角色攻击强化]*100.0f;
	属性结果[_攻击强化增幅]=当前角色对象->角色属性[DNF角色对象::角色攻击强化增幅]*100.0f;
	属性结果[_技能伤害]=当前角色对象->角色属性[DNF角色对象::角色技能伤害]*100.0f;
	for (int i=0;i<4;i++)
		属性结果[_属性强化1+i]=当前角色对象->角色属性[DNF角色对象::角色火属性强化+i];
	for (int i=0;i<4;i++)
		属性结果[_属性抗性1+i]=当前角色对象->角色属性[DNF角色对象::角色火属性抗性+i];
	属性结果[_异常伤害占比1]=当前角色对象->异常属性[出血].伤害占比*100.0f;
	属性结果[_异常伤害占比2]=当前角色对象->异常属性[中毒].伤害占比*100.0f;
	属性结果[_异常伤害占比3]=当前角色对象->异常属性[灼伤].伤害占比*100.0f;
	属性结果[_异常伤害占比4]=当前角色对象->异常属性[感电].伤害占比*100.0f;
	属性结果[_直伤占比]=(1.0-当前角色对象->异常属性[出血].伤害占比-当前角色对象->异常属性[中毒].伤害占比-
		当前角色对象->异常属性[灼伤].伤害占比-当前角色对象->异常属性[感电].伤害占比)*100.0f;
	属性结果[_异常伤害增加1]=当前角色对象->异常属性[出血].伤害增加量;
	属性结果[_异常伤害增加2]=当前角色对象->异常属性[中毒].伤害增加量;
	属性结果[_异常伤害增加3]=当前角色对象->异常属性[灼伤].伤害增加量;
	属性结果[_异常伤害增加4]=当前角色对象->异常属性[感电].伤害增加量;
	for (int i=0;i<13;i++)
		属性结果[_异常抗性1+i]=当前角色对象->角色属性[DNF角色对象::角色出血抗性+i]*100.0f;
	属性结果[_攻击速度]=当前角色对象->角色属性[DNF角色对象::角色攻击速度]*100.0f;
	属性结果[_施放速度]=当前角色对象->角色属性[DNF角色对象::角色施放速度]*100.0f;
	属性结果[_移动速度]=当前角色对象->角色属性[DNF角色对象::角色移动速度]*100.0f;
	float 装备技能冷却=1.0f-当前职业对象->技能冷却削减量;
	装备技能冷却*=当前角色对象->技能冷却减少记录;
	装备技能冷却/=1.0f+当前角色对象->技能恢复加快记录;
	属性结果[_冷却减少]=(1.0f-装备技能冷却)*100.0f;
	属性结果[_技能范围]=当前角色对象->装备技能范围*100.0f;
	属性结果[_MP消耗量]=当前角色对象->MP额外消耗量*100.0f;;
}













